home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 May: Tool Chest / Dev.CD May 97 TC.toast / Tool Chest / QuickDraw / Bitblitz 1.0 / Source / BitBlitz.c next >
Encoding:
C/C++ Source or Header  |  1990-10-09  |  51.4 KB  |  1,830 lines  |  [TEXT/MPS ]
  1. /*--------------------------------------------------------------------------------------
  2. //
  3. //    File:          BitBlitz.c
  4. //
  5. //    Contents:    This files contains all of the main routines that comprise the BitBlitz tool.
  6. //                The tool was designed to be a learning/testing tool for the Copybits(), CopyMask(),
  7. //                and CopyDeepMask() QuickDraw calls.  It makes extensive use of GWorlds as well as
  8. //                the above mentioned QuickDraw bit tools.
  9. //
  10. //
  11. //    By Georgiann ("George") Delaney
  12. //    © 1989 - 1990, Apple Computer, Inc.
  13. //
  14. //--------------------------------------------------------------------------------------*/
  15.   
  16.   
  17. #include "MacHeaders.h"
  18.  
  19. #include "WCenter.h"
  20. #include "ColorTools.h"
  21.  
  22. #include "MainStuff.h"
  23.  
  24. #include "BlendUtils.h"
  25. #include "OffscreenUtils.h"
  26. #include "PICTUtils.h"
  27. #include "AlertDlogUtils.h"
  28. #include "AlrtDlogTools.h"
  29.  
  30. #include "BitBlitz.h"
  31.  
  32.  
  33.  
  34. #pragma segment CopyTests
  35.  
  36.  
  37. /*--------------------------------------------------------------------------------------*/
  38. /*  Constants  */
  39.  
  40. #define  AttrbDlogID        300                /*  Attributes dialog constants  */
  41. #define  diDlogTitle        3
  42. #define  diLine1            4
  43. #define  diLine2              5
  44. #define  diLine3            10
  45. #define  diLine4            16
  46. #define  diBitmapButton        6
  47. #define  diGWorldButton        7
  48. #define     diDepthPopUp        8
  49. #define     diContentPopUp        9
  50. #define     diHeightText        14
  51. #define     diWidthText        15
  52.  
  53. #define  TrapDlogID            301                /*  Trap selection dialog contents  */
  54. #define     diTrapLine1         4
  55. #define  diTrapLine2         5
  56. #define  diCopyMaskButton     6
  57. #define  diCopyDeepButton       7
  58. #define  diCopyBitsButton     8
  59.  
  60. #define  Sys7DlogID            302                /*  Need 7.0 dialog constants  */
  61. #define  AboutBoxDlogID        303                
  62.  
  63.  
  64. #define  kDepthMenu            300                /*  Attributes dialog menu constants  */
  65. #define  kContentMenu        301    
  66.  
  67.         
  68. #define  kNone                0                /*  Buffer type constants  */
  69. #define  kBitMap            1
  70. #define  kPixMap            2
  71. #define  kGWorld            3
  72.     
  73. #define     km1bpp                1                /*  Constants for depth menu selecions  */ 
  74. #define     km2bpp                2
  75. #define     km4bpp                3
  76. #define     km8bpp                4
  77. #define     km16bpp            5
  78. #define     km32bpp            6
  79. #define     kmMaxbpp            8
  80. #define  kTitleStrings        4000            /*  String resource constants  */
  81.  
  82. #define  kErrorStrings        4001
  83. #define        kBootMemErr           1
  84. #define        kDepthMemErr       2
  85. #define        kResizeMemErr     3
  86. #define        kPICTReadErr       4
  87. #define  kAttribDlogStrings    4002
  88.  
  89.  
  90. #define    kHLSRectBlend        1                
  91. #define    kHLSHBlend            2
  92. #define    kHLSVBlend            3
  93. #define    kGrayRectBlend        5
  94. #define    kGrayHBlend            6
  95. #define    kGrayVBlend         7
  96. #define    kGrayPatRectBlend     9
  97. #define    kGrayPatHBlend        10
  98. #define    kGrayPatVBlend        11
  99. #define    kSolidRGB            13
  100. #define    kPICT                15
  101.  
  102.  
  103.  
  104.  
  105. /*--------------------------------------------------------------------------------------*/
  106. /*  Global Variables  */
  107.  
  108. RGBColor    gLastRGB;                /* The last RGB Color selected for a solid fill.                  
  109.                                        Used as a starting color for the color picker for selection. */
  110. Point        gZeroPt;                /* Its just what you think - a point initialized to (0,0)       */ 
  111.  
  112.                                     /* Array containing the 8 standard colors    */
  113. long        gColorArray[8]    =  {blackColor, whiteColor, redColor, greenColor, blueColor, cyanColor, magentaColor, yellowColor};    
  114.  
  115.                                     /* Array containing rgb equivalents of 8 standard colors & gray*/
  116. RGBColor    gRGBArray[9];        
  117.  
  118. /*======================================================================================*/
  119. /*  Initialization Routines        */
  120.  
  121.  
  122. /*--------------------------------------------------------------------------------------*/
  123. Boolean myTrapAvailable(theNumber,theType)
  124. /*
  125. //    This procedure tests to see if the specified trap is available in the current system.
  126. */
  127.     short        theNumber;
  128.     TrapType    theType;
  129. {
  130.     return NGetTrapAddress(theNumber,theType) != GetTrapAddress(_Unimplemented);
  131. } 
  132.  
  133. /*--------------------------------------------------------------------------------------*/
  134. Boolean HasGWorlds()
  135. /*
  136. //    This procedure tests to see if the GWorlds are available.
  137. */
  138. {
  139.     #define _GWorldDispatch (short)0xAB1D
  140.  
  141.     return(myTrapAvailable(_GWorldDispatch,ToolTrap));
  142. } 
  143.  
  144.  
  145. /*--------------------------------------------------------------------------------------*/
  146. void InitTestGlobals()
  147. /*
  148. //    This procedure is called during the program's initialization to set the initial values
  149. //    of the app's constants.
  150. */
  151. {
  152.     gColorAvail   = HasColorQD();
  153.     gGWorldsAvail = HasGWorlds();
  154.     gZeroPt.h      = gZeroPt.v  = 0;
  155. }
  156.  
  157.  
  158. /*--------------------------------------------------------------------------------------*/
  159. void  InitTestWindowAttributes()
  160. /*
  161. //    InitTestWindowAttributes() performs initialization of the global structs defining the  
  162. //    attributes of the source, mask, and destination bit images.
  163. */
  164. {
  165.     register    i;
  166.     
  167.             /*  initialize all of the common fields  */
  168.     for (i=kSrcWindow; i <= kBitWindow; i++)  {
  169.         gWList[i].window            = nil;
  170.         gWList[i].buffer.gworld        = nil;
  171.         
  172.         if (gGWorldsAvail)  {
  173.             gWList[i].bufferType    = kGWorld;
  174.             gWList[i].bufferDepth    = 0;
  175.             }
  176.         else  {
  177.             gWList[i].bufferType    = kBitMap;
  178.             gWList[i].bufferDepth    = 1;
  179.             }
  180.         }
  181.  
  182.             /*  set initial window contents with respect to the availability of color.  */
  183.     if (gColorAvail)  {
  184.         gWList[kSrcWindow].contentType            = kHLSRectBlend;
  185.         gWList[kSrcWindow].content.saturation    = 65535;
  186.     
  187.         gWList[kMskWindow].contentType            = kGrayVBlend;
  188.     
  189.         gWList[kDstWindow].contentType            = kSolidRGB;
  190.         gWList[kDstWindow].content.RGB.red        = 0xFFFF;
  191.         gWList[kDstWindow].content.RGB.green     = 0xFFFF;
  192.         gWList[kDstWindow].content.RGB.blue        = 0x0000;
  193.         }
  194.     else  {
  195.         gWList[kSrcWindow].contentType            = kGrayPatRectBlend;
  196.         gWList[kMskWindow].contentType            = kGrayPatVBlend;
  197.         gWList[kDstWindow].contentType            = kGrayPatHBlend;
  198.         }
  199. }
  200.  
  201.  
  202. /*--------------------------------------------------------------------------------------*/
  203. void  InitColorSettings()
  204. /*
  205. //    InitColorSettings() initializes the values in the color array.
  206. */
  207. {
  208.     gRGBArray[0].red   = 0x0000;    gRGBArray[0].green = 0x0000;    gRGBArray[0].blue  = 0x0000;
  209.     gRGBArray[1].red   = 0xFFFF;    gRGBArray[1].green = 0xFFFF;    gRGBArray[1].blue  = 0xFFFF;
  210.     gRGBArray[2].red   = 0xDD6B;    gRGBArray[2].green = 0x08C2;    gRGBArray[2].blue  = 0x06A2;
  211.     gRGBArray[3].red   = 0x0000;    gRGBArray[3].green = 0x8000;    gRGBArray[3].blue  = 0x11B0;
  212.     gRGBArray[4].red   = 0x0000;    gRGBArray[4].green = 0x0000;    gRGBArray[4].blue  = 0xD400;
  213.     gRGBArray[5].red   = 0x0241;    gRGBArray[5].green = 0xAB54;    gRGBArray[5].blue  = 0xEAFF;
  214.     gRGBArray[6].red   = 0xF2D7;    gRGBArray[6].green = 0x0856;    gRGBArray[6].blue  = 0x84EC;
  215.     gRGBArray[7].red   = 0xFC00;    gRGBArray[7].green = 0xF37D;    gRGBArray[7].blue  = 0x052F;
  216.     gRGBArray[8].red   = 0x7FFF;    gRGBArray[8].green = 0x7FFF;    gRGBArray[8].blue  = 0x7FFF;
  217.  
  218.  
  219.     gFGColor.menuIndex         = kBlack;
  220.     gFGColor.rgb            = gRGBArray[kBlack-1];
  221.     
  222.     gBKColor.menuIndex         = kWhite;
  223.     gBKColor.rgb            = gRGBArray[kWhite-1];
  224.  
  225.     gOPColor.menuIndex        = kGray;
  226.     gOPColor.rgb            = gRGBArray[kGray-1];
  227.  
  228.     gHiliteColor.menuIndex    = kBlue;
  229.     gHiliteColor.rgb        = gRGBArray[kBlue-1];
  230. }
  231.  
  232. /*--------------------------------------------------------------------------------------*/
  233. void  InitRgnSettings()
  234. /*
  235. //    InitRgnSettings() initializes all of the region settings to nil.
  236. */
  237. {
  238.     register    i;
  239.     
  240.     for (i=kClpRgn; i<=kMskRgn; i++)  {
  241.         gRList[i].type = kNoRgn;
  242.         gRList[i].rgn  = nil;
  243.         }
  244. }
  245.  
  246.  
  247. /*--------------------------------------------------------------------------------------*/
  248. void  DisposeRgnSettings()
  249. /*
  250. //    DisposeRgnSettings() disposes any region settings that may have been set by the user.
  251. */
  252. {
  253.     register    i;
  254.     
  255.     for (i=kClpRgn; i<=kMskRgn; i++)  {
  256.         if (gRList[i].rgn != nil)  {
  257.             DisposeRgn(gRList[i].rgn);
  258.             gRList[i].rgn = nil;
  259.             }
  260.         }
  261. }
  262.  
  263.  
  264.  
  265. /*--------------------------------------------------------------------------------------*/
  266. void  MenuIndex2RGB(ColorAttributes colorSelect, RGBColor *theRGB)
  267. {
  268.     if (colorSelect.menuIndex == kCustomColor)
  269.         *theRGB = colorSelect.rgb;
  270.     else
  271.         *theRGB = gRGBArray[colorSelect.menuIndex-1];
  272. }
  273.  
  274.  
  275. /*--------------------------------------------------------------------------------------*/
  276. void  DrawOval()
  277. {
  278.     Rect    tempRect;
  279.  
  280.     tempRect = gWList[kBitWindow].window->portRect;
  281.     
  282.     InsetRect(&tempRect, 10, 10);
  283.     FrameOval(&tempRect);
  284. }
  285.  
  286. /*--------------------------------------------------------------------------------------*/
  287. void  DrawDiamond()
  288. {
  289.     Rect    tempRect;
  290.     Point    centerPt;
  291.  
  292.     tempRect = gWList[kBitWindow].window->portRect;
  293.     
  294.     InsetRect(&tempRect, 10, 10);
  295.     
  296.     centerPt.h = tempRect.left + ((tempRect.right  - tempRect.left)>>1);
  297.     centerPt.v = tempRect.top  + ((tempRect.bottom - tempRect.top )>>1);
  298.     
  299.     MoveTo(centerPt.h,        tempRect.top);
  300.     LineTo(tempRect.right,    centerPt.v);
  301.     LineTo(centerPt.h,        tempRect.bottom);
  302.     LineTo(tempRect.left,    centerPt.v);
  303.     LineTo(centerPt.h,        tempRect.top);
  304. }
  305.  
  306. /*--------------------------------------------------------------------------------------*/
  307. void  DrawHole()
  308. {
  309.     Rect    tempRect;
  310.  
  311.     tempRect = gWList[kBitWindow].window->portRect;
  312.     
  313.     InsetRect(&tempRect, 10, 10);
  314.     FrameOval(&tempRect);
  315.  
  316.     InsetRect(&tempRect, ((tempRect.right  - tempRect.left)>>2), ((tempRect.bottom - tempRect.top )>>2));
  317.     FrameOval(&tempRect);
  318. }
  319.  
  320.  
  321. /*--------------------------------------------------------------------------------------*/
  322. void  DrawStar()
  323. {
  324.     Rect    tempRect;
  325.     Point    centerPt;
  326.  
  327.     tempRect = gWList[kBitWindow].window->portRect;
  328.     
  329.     InsetRect(&tempRect, 10, 10);
  330.     
  331.     centerPt.h = tempRect.left + ((tempRect.right  - tempRect.left)>>1);
  332.     centerPt.v = tempRect.top  + ((tempRect.bottom - tempRect.top )/3);
  333.     
  334.     MoveTo(centerPt.h,        tempRect.top);
  335.     LineTo(tempRect.right,    tempRect.bottom);
  336.     LineTo(tempRect.left,    centerPt.v);
  337.     LineTo(tempRect.right,    centerPt.v);
  338.     LineTo(tempRect.left,    tempRect.bottom);
  339.     LineTo(centerPt.h,        tempRect.top);
  340. }
  341.  
  342.  
  343. /*--------------------------------------------------------------------------------------*/
  344. void  UpdateRgnSettings()
  345. /*
  346. //    UpdateRgnSettings() updates any region settings that the user has selected after the 
  347. //  corresponding window has been resized.
  348. */
  349. {
  350.     register    i;
  351.     
  352.     
  353.     DisposeRgnSettings();
  354.     
  355.     for (i=kClpRgn; i<=kMskRgn; i++) 
  356.  
  357.         if (gRList[i].type != kNoRgn)  {
  358.             gRList[i].rgn = NewRgn();
  359.             OpenRgn();
  360.     
  361.             switch(gRList[i].type)  {
  362.                 case kDiamondClip:    DrawDiamond();        break;
  363.                 case kOvalClip:        DrawOval();            break;
  364.                 case kStarClip:        DrawStar();            break;
  365.                 case kHoleClip:        DrawHole();            break;
  366.                 }
  367.     
  368.             CloseRgn(gRList[i].rgn);
  369.             }
  370. }
  371.  
  372.  
  373. /*--------------------------------------------------------------------------------------*/
  374. void  SetEnv()
  375. /*
  376. //    SetEnv() is called to set the color environment and clip regions the user haa designated
  377. //  for use in the copy call.
  378. */
  379. {
  380.     GrafPtr        thePort;
  381.     
  382.  
  383.     if (gColorAvail)  {
  384.         RGBForeColor(&gFGColor.rgb);
  385.         RGBBackColor(&gBKColor.rgb);
  386.         OpColor     (&gOPColor.rgb);
  387.         HiliteColor (&gHiliteColor.rgb);
  388.         }
  389.     else  {
  390.         ForeColor(gColorArray[gFGColor.menuIndex-1]);
  391.         BackColor(gColorArray[gBKColor.menuIndex-1]);
  392.         }
  393.     
  394.     if (gRList[kClpRgn].rgn != nil)  {
  395.         gHoldClpRgn = NewRgn();
  396.         GetClip(gHoldClpRgn);
  397.         SetClip(gRList[kClpRgn].rgn);
  398.         }
  399.  
  400.     if (gRList[kVisRgn].rgn != nil)  {
  401.         GetPort(&thePort);
  402.         gHoldVisRgn     = thePort->visRgn;
  403.         thePort->visRgn = gRList[kVisRgn].rgn;
  404.         }
  405. }
  406.  
  407.  
  408. /*--------------------------------------------------------------------------------------*/
  409. void  RestoreEnv()
  410. /*
  411. //    RestoreEnv() restores the color and clip settings following the copy call.
  412. */
  413. {
  414.     GrafPtr        thePort;
  415.     
  416.     if (gColorAvail)  {
  417.         RGBForeColor(&gRGBArray[kBlack-1]);
  418.         RGBBackColor(&gRGBArray[kWhite-1]);
  419.         }
  420.     else  {
  421.         ForeColor(gColorArray[kBlack-1]);
  422.         BackColor(gColorArray[kWhite-1]);
  423.         }
  424.         
  425.  
  426.     if (gHoldClpRgn != nil)  {
  427.         SetClip(gHoldClpRgn);
  428.         DisposeRgn(gHoldClpRgn);
  429.         gHoldClpRgn = nil;
  430.         }
  431.  
  432.     if (gHoldVisRgn != nil)  {
  433.         GetPort(&thePort);
  434.         thePort->visRgn     = gHoldVisRgn;
  435.         }
  436.             
  437. }
  438.  
  439.  
  440.  
  441. /*======================================================================================*/
  442. /*  Routines to handle CopyMode selection    */
  443.  
  444.  
  445. /*--------------------------------------------------------------------------------------*/
  446. short  ModeMenuItem2CopyMode(short theItem)
  447. /*
  448. //  This routine is used to convert a copy mode menu selection to an actual QuickDraw 
  449. //  copy mode.   The reason a switch statement is required here is because the 
  450. //    QuickDraw copy mode constants are not contiguous.
  451. */
  452. {
  453.     short    theMode;
  454.     
  455.     switch(theItem)  {
  456.         case kSrcCopy:        if (gDither) 
  457.                                   theMode = ditherCopy;
  458.                             else theMode = theItem -1;        
  459.                             break;
  460.         case kSrcOr:
  461.         case kSrcXor:
  462.         case kSrcBic:
  463.         case kNotSrcCopy:
  464.         case kNotSrcOr:
  465.         case kNotSrcXor:
  466.         case kNotSrcBic:    theMode = theItem -1;        break;
  467.  
  468.         case kBlend:        theMode = blend;            break;
  469.         case kAddPin:        theMode = addPin;            break;
  470.         case kAddOver:        theMode = addOver;            break;
  471.         case kAddMax:        theMode = addMax;            break;
  472.         case kAddMin:        theMode = adMin;            break;
  473.         case kSubOver:        theMode = subOver;            break;
  474.         case kSubPin:        theMode = subPin;            break;
  475.         
  476.         case kTransparent:    theMode = transparent;        break;
  477.         
  478.         case kHilite:        theMode = hilite;            break;
  479.         }
  480.     
  481.     return(theMode);
  482. }
  483.  
  484.  
  485. /*--------------------------------------------------------------------------------------*/
  486. short  CopyMode2ModeMenuItem(short theMode)
  487. /*
  488. //  This routine is used to convert a QuickDraw copy mode to a copy mode menu selection.
  489. //  The reason a switch statement is required here is because the QuickDraw copy mode
  490. //  constants are not contiguous.
  491. */
  492. {
  493.     short  theItem;
  494.     
  495.     switch(theMode)  {
  496.         case ditherCopy:    theItem = srcCopy +1;         break;
  497.         
  498.         case srcCopy:
  499.         case srcOr:
  500.         case srcXor:
  501.         case srcBic:
  502.         case notSrcOr:
  503.         case notSrcCopy:
  504.         case notSrcXor:
  505.         case notSrcBic:        theItem = theMode +1;        break;
  506.  
  507.         case blend:            theItem = kBlend;            break;
  508.         case addPin:        theItem = kAddPin;            break;
  509.         case addOver:        theItem = kAddOver;            break;
  510.         case adMin    :        theItem = kAddMin;            break;
  511.         case addMax:        theItem = kAddMax;            break;
  512.         case subOver:        theItem = kSubOver;            break;
  513.         case subPin:        theItem = kSubPin;            break;
  514.         
  515.         case transparent:    theItem = kTransparent;        break;
  516.         
  517.         case hilite:        theItem = kHilite;            break;
  518.         }
  519.         
  520.     return(theItem);
  521. }
  522.  
  523.   
  524.   
  525. /*======================================================================================*/
  526. /*  Window Attribute PICT handle cleanup.    */
  527.  
  528.  
  529. /*--------------------------------------------------------------------------------------*/
  530. void  DisposePICTInfo(short windowCode)
  531. /*    
  532. //    DisposePICTInfo() tests to determine if the specified window has a PICT handle allocated 
  533. //    for buffer updating and disposes it if it is not already nil.
  534. */
  535. {
  536.     if ((gWList[windowCode].contentType == kPICT) && (gWList[windowCode].content.pictInfo != nil))  {
  537.         DisposHandle((Handle)gWList[windowCode].content.pictInfo);
  538.         gWList[windowCode].content.pictInfo = nil;
  539.         }
  540. }
  541.  
  542.  
  543.  
  544. /*======================================================================================*/
  545. /*  Offscreen Buffer Maintainance Routines     */
  546.  
  547.  
  548. /*--------------------------------------------------------------------------------------*/
  549. Boolean  CreateWindowBuffer(short windowCode)
  550. /*    
  551. //    CreateWindowBuffer() creates an offscreen buffer of the designated size with respect to the
  552. //    attributes set in the window's attribute information.
  553. */
  554. {
  555.     Boolean        bufferCreated    = false;
  556.     
  557.     switch(gWList[windowCode].bufferType) {
  558.         case kBitMap:    
  559.             bufferCreated = CreateOSBitmap(&gWList[windowCode].buffer.bitmap, &gWList[windowCode].window->portRect);
  560.             break;
  561.         case kGWorld:                
  562.             bufferCreated = (NewGWorld(&gWList[windowCode].buffer.gworld, gWList[windowCode].bufferDepth, &gWList[windowCode].window->portRect, nil, nil, 0) == noErr);
  563.             break;
  564.         }
  565.     
  566.     return(bufferCreated);
  567. }
  568.  
  569.  
  570. /*--------------------------------------------------------------------------------------*/
  571. Boolean  UpdateWindowBuffer(short windowCode, short depth)    
  572. /* 
  573. //    This routine updates the specified window's offscreen buffer to the desired depth.
  574. */
  575. {
  576.     Boolean  bufferChanged  = false;
  577.     long     gwError;
  578.     
  579.     if (gWList[windowCode].bufferType == kGWorld) {    
  580.         gWList[windowCode].bufferDepth = depth;
  581.         
  582.         gwError = (UpdateGWorld(&gWList[windowCode].buffer.gworld, depth, &gWList[windowCode].buffer.gworld->portRect, 0, 0, 0) == noErr);
  583.         bufferChanged = (gwError & gwFlagErr);
  584.         }
  585.         
  586.     return(true);
  587. }
  588.  
  589.  
  590. /*--------------------------------------------------------------------------------------*/
  591. void  DisposeWindowBuffer(short windowCode)
  592. /*    
  593. //    DisposeWindowBuffer() determines the type of buffer that is associated with the specified 
  594. //    window and performs the appropriate dispose.
  595. */
  596. {
  597.     if (gWList[windowCode].buffer.gworld != nil) 
  598.         switch(gWList[windowCode].bufferType) {
  599.             case kBitMap:    DisposeOSBitmap(gWList[windowCode].buffer.bitmap);    break;
  600.             case kGWorld:    DisposeGWorld  (gWList[windowCode].buffer.gworld);    break;
  601.             }
  602. }
  603.  
  604.  
  605. /*--------------------------------------------------------------------------------------*/
  606. Boolean  SetOffscreen(short windowCode, short type, short depth)    
  607. /*
  608. //    Hey, guess what, it does what you expect - sets the specified window's buffer to the
  609. //  specified offscreen type and depth.
  610. */
  611. {
  612.     Boolean        bufferChanged     = false;    
  613.  
  614.             
  615.     if (type != gWList[windowCode].bufferType) {
  616.         DisposeWindowBuffer(windowCode);
  617.         
  618.         gWList[windowCode].bufferType  = type;
  619.         gWList[windowCode].bufferDepth = depth;
  620.         bufferChanged = CreateWindowBuffer(windowCode);
  621.         if (!bufferChanged)
  622.             OKRsrcAlert(kErrorStrings,kDepthMemErr);
  623.         }
  624.     else  {
  625.         if (depth != gWList[windowCode].bufferDepth)  {
  626.             gWList[windowCode].bufferDepth = depth;
  627.             bufferChanged = UpdateWindowBuffer(windowCode, depth);
  628.             if (!bufferChanged)
  629.                 OKRsrcAlert(kErrorStrings,kDepthMemErr);
  630.             }
  631.         }
  632.     
  633.     return(bufferChanged);
  634. }
  635.  
  636.  
  637. /*--------------------------------------------------------------------------------------*/
  638. Boolean  UpdateOffscreen(short windowCode, short type, short depth)
  639. /*
  640. //    UpdateOffscreen() tests to determine if the specified window's offscreen buffer has the 
  641. //  specified type and depth attributes and  performs whatever buffer updating necessary.
  642. */
  643. {
  644.     Boolean    depthChanged = false;
  645.     
  646.  
  647.     depthChanged = SetOffscreen(windowCode,type,depth);
  648.     
  649.                 /*  Since the dest and copy window must be the same depth, if the user changes 
  650.                 //    the depth of the dest window, the copy window should also be set to the 
  651.                 //  new selected depth/
  652.                 */
  653.     if ((depthChanged) && (windowCode == kDstWindow))  {
  654.         depthChanged = SetOffscreen(kBitWindow,type,depth);
  655.             
  656.                 /*  However, if an error occurs and the copy window can not be set to the
  657.                 //  new depth then return the dest window to the original depth so that both are
  658.                 //  equal.
  659.                 */
  660.         if (!depthChanged) 
  661.             SetOffscreen(kDstWindow,gWList[kBitWindow].bufferType,gWList[kBitWindow].bufferDepth);
  662.         }
  663.         
  664.     if (depthChanged)  {
  665.         DrawBuffer(windowCode);
  666.         DrawBuffer(kBitWindow);
  667.         }
  668.                 
  669.     return(depthChanged);
  670. }
  671.  
  672.  
  673.  
  674. /*======================================================================================*/
  675. /*  Attributes Dialog Routines     */
  676.  
  677.  
  678. /*--------------------------------------------------------------------------------------*/
  679. void  SetDepthMenuSelection(DialogPtr  theDlog, short  theItem, short theDepth)
  680. /*
  681. //    This procedure initializes the attributes dialog's depth popup to the depth of the 
  682. //    selected window's offscreen depth.
  683. */
  684. {
  685.     short        itemType;
  686.     Handle        itemHdl;
  687.     Rect        itemRect;
  688.     
  689.     short        selection;
  690.     MenuHandle    depthMenuHdl;
  691.  
  692.     
  693.     depthMenuHdl = GetMHandle(kDepthMenu);
  694.     if ((!gGWorldsAvail) || (!gColorAvail))  {
  695.         DisableItem(depthMenuHdl, km2bpp);
  696.         DisableItem(depthMenuHdl, km4bpp);
  697.         DisableItem(depthMenuHdl, km8bpp);
  698.         DisableItem(depthMenuHdl, km16bpp);
  699.         DisableItem(depthMenuHdl, km32bpp);
  700.         }
  701.         
  702.     if (!gGWorldsAvail)  
  703.         DisableItem(depthMenuHdl, kmMaxbpp);
  704.  
  705.     GetDItem(theDlog,theItem,&itemType,&itemHdl,&itemRect);
  706.     
  707.     switch(theDepth)  {   
  708.         case 1    : selection = km1bpp;    break;
  709.         case 2    : selection = km2bpp;    break;
  710.         case 4    : selection = km4bpp;    break;
  711.         case 8    : selection = km8bpp;    break;
  712.         case 16    : selection = km16bpp;    break;
  713.         case 32    : selection = km32bpp;    break;
  714.         case 0    : selection = kmMaxbpp;    break;
  715.         }
  716.     
  717.     SetCtlValue((ControlHandle)itemHdl,selection);
  718. }
  719.  
  720.  
  721. /*--------------------------------------------------------------------------------------*/
  722. short  GetDepthMenuSelection(DialogPtr  theDlog, short  theItem)
  723. /*
  724. //    This procedure converts the attributes dialog's depth popup selection to its
  725. //    equivalent depth value.
  726. */
  727. {
  728.     short        itemType;
  729.     Handle        itemHdl;
  730.     Rect        itemRect;
  731.     
  732.     short        selection,depth;
  733.  
  734.  
  735.     GetDItem(theDlog,theItem,&itemType,&itemHdl,&itemRect);
  736.     selection = GetCtlValue((ControlHandle)itemHdl);
  737.     
  738.     switch(selection)  {   
  739.         case km1bpp     : depth = 1;    break;
  740.         case km2bpp     : depth = 2;    break;
  741.         case km4bpp     : depth = 4;    break;
  742.         case km8bpp     : depth = 8;    break;
  743.         case km16bpp : depth = 16;    break;
  744.         case km32bpp : depth = 32;    break;
  745.         case kmMaxbpp: depth = 0;    break;
  746.         }
  747.     
  748.     return(depth);
  749. }
  750.  
  751.  
  752. /*--------------------------------------------------------------------------------------*/
  753. void  SetContentMenuSelection(DialogPtr  theDlog, short  theItem, short theContent)
  754. /*
  755. //    This procedure initializes the attributes dialog's content popup to reflect the 
  756. //    selected window's current content type.
  757. */
  758. {
  759.     short        itemType;
  760.     Handle        itemHdl;
  761.     Rect        itemRect;
  762.     MenuHandle    contentMenuHdl;
  763.  
  764.     contentMenuHdl = GetMHandle(kContentMenu);
  765.     if (!gColorAvail)  {
  766.         DisableItem(contentMenuHdl, kHLSRectBlend);
  767.         DisableItem(contentMenuHdl, kHLSHBlend);
  768.         DisableItem(contentMenuHdl, kHLSVBlend);
  769.         DisableItem(contentMenuHdl, kGrayRectBlend);
  770.         DisableItem(contentMenuHdl, kGrayHBlend);
  771.         DisableItem(contentMenuHdl, kGrayVBlend);
  772.         DisableItem(contentMenuHdl, kSolidRGB);
  773.         }
  774.  
  775.     GetDItem(theDlog,theItem,&itemType,&itemHdl,&itemRect);
  776.     SetCtlValue((ControlHandle)itemHdl,theContent);
  777. }
  778.  
  779.  
  780. /*--------------------------------------------------------------------------------------*/
  781. short  GetContentMenuSelection(DialogPtr  theDlog, short  theItem)
  782. /*
  783. //    This procedure returns the attributes dialog's content popup selection.
  784. */
  785. {
  786.     short        itemType;
  787.     Handle        itemHdl;
  788.     Rect        itemRect;
  789.  
  790.  
  791.     GetDItem(theDlog,theItem,&itemType,&itemHdl,&itemRect);
  792.     return(GetCtlValue((ControlHandle)itemHdl));
  793. }
  794.  
  795.  
  796. /*--------------------------------------------------------------------------------------*/
  797. pascal Boolean AttrbDlogFilter(DialogPtr theDlog, EventRecord *theEvent, short *theItem)
  798. {
  799.  /*
  800.  //  AttrbDlogFilter() is the dialog filter for the attributes  dialog.
  801.  */
  802.  
  803.                  
  804.     IBeamCursorAdjust(theDlog,(ValidTextProcPtr)StdValidDecTextProc);
  805.  
  806.                 /*  If we get a key down event, check to see if it is for the OK or Cancel
  807.                 //  buttons.  If not, filter it for numeric input only (via EditNumText()).
  808.                 */
  809.     if ((theEvent->what == autoKey) || (theEvent->what == keyDown))  {
  810.         short editItem = ((DialogPeek)theDlog)->editField + 1;
  811.         
  812.         if (HandleOkayCancel(theDlog,theEvent,theItem))
  813.             return(true);
  814.  
  815.         EditNumText(theDlog,theEvent,editItem,0L,1000L,decimalOnly);
  816.         }
  817.         
  818.     return(false);
  819. }
  820.  
  821.  
  822. /*--------------------------------------------------------------------------------------*/
  823. Boolean  ChangeWindowAttributes(short windowCode)
  824. /*
  825. //    ChangeWindowAttributes() allows the user to change any of the attributes of the source, 
  826. //  mask, or destination windows.
  827. //
  828. //  This dialog is accessed by selecting the appropriate menu selection or by double-clicking 
  829. //  in the content region of the desired window.
  830. */
  831. {
  832.     DialogPtr    theDlog;
  833.     GrafPtr        holdPort;
  834.     short        itemHit;
  835.     
  836.     Boolean        okHit            = false;
  837.     Boolean        done            = false;
  838.     Boolean        bufferChanged    = false;
  839.     Boolean        contentChanged    = false;
  840.  
  841.     short        tempBufferType   = gWList[windowCode].bufferType;
  842.     short        tempBufferDepth  = gWList[windowCode].bufferDepth;
  843.     short        tempContentType  = gWList[windowCode].contentType;
  844.     PicHandle    tempPICT         = nil;  
  845.     short        tempSaturation     = 65535;  
  846.     RGBColor    tempRGB;
  847.     
  848.     register     i;
  849.     short        contentSelect;
  850.     SFReply        reply;
  851.     Str255        tempStr;
  852.     
  853.     Point        oldDimen, newDimen;
  854.     
  855.     
  856.                 /*  Initialize temporary values that have not already been initialized during
  857.                 //    variable declaration.
  858.                 */
  859.     if (tempContentType == kSolidRGB) 
  860.         tempRGB = gWList[windowCode].content.RGB;
  861.     else
  862.         tempRGB = gLastRGB;
  863.  
  864.             
  865.                 /*  Allocate and center the dialog  */
  866.     CenterWRsrc(DLOG,AttrbDlogID,vThird);
  867.     theDlog = GetNewDialog(AttrbDlogID, nil, (WindowPtr)-1);
  868.     
  869.     reply.good = false;
  870.     
  871.                 /*  If the dialog has been allocated successfully - process the user's selections  */
  872.     if (theDlog != nil)  {
  873.     
  874.                 /*  Save off the current port.  */
  875.         GetPort(&holdPort);
  876.         SetPort(theDlog);
  877.         
  878.                 /*  Dialog item initialization.  */
  879.         SetDlogItemProc(theDlog,diLine1,(ProcPtr)FrameDlogItemRect);
  880.         SetDlogItemProc(theDlog,diLine2,(ProcPtr)FrameDlogItemRect);
  881.         SetDlogItemProc(theDlog,diLine3,(ProcPtr)FrameDlogItemRect);
  882.         SetDlogItemProc(theDlog,diLine4,(ProcPtr)FrameDlogItemRect);
  883.         
  884.                 /*  Set the appropriate dialog title  */
  885.           GetIndString (tempStr,kAttribDlogStrings,windowCode+1);
  886.           SetDlogString(theDlog, diDlogTitle, tempStr);
  887.  
  888.         HandleRadioButtons(theDlog,diBitmapButton,diGWorldButton,((tempBufferType == kGWorld) ? diGWorldButton : diBitmapButton));
  889.         SetDepthMenuSelection  (theDlog, diDepthPopUp,  tempBufferDepth);
  890.         SetContentMenuSelection(theDlog, diContentPopUp,tempContentType);
  891.  
  892.         oldDimen.v = gWList[windowCode].window->portRect.bottom - gWList[windowCode].window->portRect.top;
  893.         oldDimen.h = gWList[windowCode].window->portRect.right  - gWList[windowCode].window->portRect.left;
  894.  
  895.         SetDlogShort(theDlog,diHeightText,oldDimen.v);
  896.         SetDlogShort(theDlog,diWidthText, oldDimen.h);
  897.         SelIText    (theDlog,diHeightText, 0, 32767);
  898.     
  899.                 /*  Display the dialog  */
  900.         ShowWindow(theDlog);
  901.         
  902.                 /*  Process the user's actions  */
  903.         do  {
  904.             ModalDialog((ProcPtr)AttrbDlogFilter, &itemHit);
  905.             
  906.             switch (itemHit)  {
  907.                     case  ok:                okHit = true;        
  908.                     case  cancel:            done  = true;
  909.                                             break;
  910.                 
  911.                     case  diBitmapButton:     HandleRadioButtons(theDlog,diBitmapButton,diGWorldButton,itemHit);
  912.                                             tempBufferDepth = 1;
  913.                                             tempBufferType  = kBitMap;
  914.                                             break;
  915.                                             
  916.                     case  diDepthPopUp:
  917.                     case  diGWorldButton:    HandleRadioButtons(theDlog,diBitmapButton,diGWorldButton,diGWorldButton);
  918.                                             tempBufferDepth = GetDepthMenuSelection(theDlog, diDepthPopUp);
  919.                                             tempBufferType  = kGWorld;
  920.                                             break;
  921.                 
  922.     
  923.                     case  diContentPopUp:    contentSelect = GetContentMenuSelection(theDlog, diContentPopUp);
  924.                                         
  925.                                             switch(contentSelect) {
  926.                                                 case kSolidRGB :     
  927.                                                         GetColor(gZeroPt,"\pSelect a color.",&tempRGB,&tempRGB);
  928.                                                         tempContentType = contentSelect;
  929.                                                         for(i=kSrcWindow; i <= kBitWindow; i++)
  930.                                                             DrawWindow(i);
  931.                                                         break;
  932.                                                 
  933.                                                 case kPICT:    
  934.                                                         StdGetPictFile(&reply);
  935.                                                         for(i=kSrcWindow; i <= kBitWindow; i++)
  936.                                                             DrawWindow(i);
  937.                                                         if (reply.good)
  938.                                                             tempContentType = contentSelect;
  939.                                                         break;
  940.                                                         
  941.                                                 default:  tempContentType = contentSelect;
  942.                                                 }
  943.                                             break;
  944.                     }
  945.             }  while ( !done );
  946.  
  947.         GetDlogShort(theDlog,diHeightText, &newDimen.v);
  948.         GetDlogShort(theDlog,diWidthText,  &newDimen.h);
  949.         
  950.         if (newDimen.v < 2)  newDimen.v = 2;
  951.         if (newDimen.h < 2)  newDimen.h = 2;
  952.         
  953.         DisposDialog(theDlog);
  954.         SetPort(holdPort);
  955.         }
  956.         
  957.     if (okHit) {
  958.         SetCursor(*GetCursor(watchCursor));
  959.         
  960.         for(i=kSrcWindow; i <= kBitWindow; i++)
  961.             DrawWindow(i);
  962.             
  963.                 /* Reset the offscreen depth if it has been changed  */
  964.         bufferChanged = UpdateOffscreen(windowCode, tempBufferType, tempBufferDepth);
  965.             
  966.                 
  967.                 /* Reset the content region if a new type has been selected */
  968.         if ((tempContentType != gWList[windowCode].contentType) ||
  969.             (tempContentType == kPICT) || (tempContentType == kSolidRGB)) {
  970.             if (tempContentType == kPICT) {
  971.                 if (ReadPICTFile(&reply, &tempPICT) == noErr) {
  972.                     if (gWList[windowCode].contentType == kPICT)
  973.                         DisposePICTInfo(windowCode);
  974.                     gWList[windowCode].contentType         = kPICT;
  975.                     gWList[windowCode].content.pictInfo  = tempPICT;
  976.                     DrawBuffer(windowCode);
  977.                     contentChanged = true;
  978.                     }
  979.                 else
  980.                     if (reply.good)
  981.                         OKRsrcAlert(kErrorStrings,kPICTReadErr);
  982.                 }
  983.             else  {
  984.                 if (gWList[windowCode].contentType == kPICT)
  985.                     DisposePICTInfo(windowCode);
  986.                     
  987.                 gWList[windowCode].contentType = tempContentType;
  988.                 
  989.                 switch(tempContentType)  {
  990.                     case kSolidRGB:     gWList[windowCode].content.RGB = gLastRGB = tempRGB;      break;
  991.                     case kHLSRectBlend: 
  992.                     case kHLSHBlend:     
  993.                     case kHLSVBlend:     gWList[windowCode].content.saturation = tempSaturation;    break;
  994.                     }
  995.                     
  996.                 DrawBuffer(windowCode);
  997.                 contentChanged = true;
  998.                 }
  999.             }
  1000.         
  1001.  
  1002.                 /*  Resize the window if the size has been altered.  Remember, the source and 
  1003.                 //  mask windows (when available)  as well as the destination and copy windows
  1004.                 //  must be the same size so if one is altered its corresponding window must also
  1005.                 //  be sized.  It therefore follows that if there is not enough memory available to
  1006.                 //  enlarge both windows then neither should be changed.  
  1007.                 */
  1008.         if ( !EqualPt(oldDimen, newDimen) )  {
  1009.             GetPort(&holdPort);
  1010.             
  1011.             if ((windowCode == kSrcWindow) || (windowCode == kMskWindow)) {
  1012.                 SetPort(gWList[kSrcWindow].window);
  1013.                 if (ResizeTestWindow(&newDimen,kSrcWindow)) { 
  1014.                     oldDimen.h = gWList[kSrcWindow].window->portRect.right  - gWList[kSrcWindow].window->portRect.left;
  1015.                     oldDimen.v = gWList[kSrcWindow].window->portRect.bottom - gWList[kSrcWindow].window->portRect.top;
  1016.     
  1017.                     SetPort(gWList[kMskWindow].window);
  1018.                     if (ResizeTestWindow(&newDimen,kMskWindow))  {
  1019.                         SizeWindow(gWList[kMskWindow].window,newDimen.h,newDimen.v,false);
  1020.                         SizeWindow(gWList[kSrcWindow].window,newDimen.h,newDimen.v,false);
  1021.                         }
  1022.                     else {
  1023.                         SetPort(gWList[kSrcWindow].window);
  1024.                         ResizeTestWindow(&oldDimen,kSrcWindow);
  1025.                         }
  1026.                     }
  1027.                 }
  1028.     
  1029.             if ((windowCode == kDstWindow) || (windowCode == kBitWindow)) {
  1030.                 SetPort(gWList[kDstWindow].window);
  1031.                 if (ResizeTestWindow(&newDimen,kDstWindow))  {
  1032.                     oldDimen.h = gWList[kDstWindow].window->portRect.right  - gWList[kDstWindow].window->portRect.left;
  1033.                     oldDimen.v = gWList[kDstWindow].window->portRect.bottom - gWList[kDstWindow].window->portRect.top;
  1034.                     
  1035.                     SetPort(gWList[kBitWindow].window);
  1036.                     if (ResizeTestWindow(&newDimen,kBitWindow))  {
  1037.                         SizeWindow(gWList[kBitWindow].window,newDimen.h,newDimen.v,false);
  1038.                         SizeWindow(gWList[kDstWindow].window,newDimen.h,newDimen.v,false);
  1039.                         UpdateRgnSettings();
  1040.                         }
  1041.                     else {
  1042.                         SetPort(gWList[kDstWindow].window);
  1043.                         ResizeTestWindow(&oldDimen,kDstWindow);
  1044.                         }
  1045.                     }
  1046.                 }
  1047.                 
  1048.             SetPort(holdPort);
  1049.             bufferChanged = true;
  1050.             }
  1051.                 /*  Update the screen with the new changes  */
  1052.         if (bufferChanged || contentChanged)
  1053.             DrawBuffer(kBitWindow);
  1054.             for(i=kSrcWindow; i <= kBitWindow; i++)
  1055.                 DrawWindow(i);
  1056.         
  1057.         InitCursor();
  1058.         }
  1059.         
  1060.     return(okHit);
  1061. }
  1062.  
  1063.  
  1064. /*--------------------------------------------------------------------------------------*/
  1065. void  SelectFGColor (short theItem)
  1066. {
  1067.     register    i;
  1068.     RGBColor    tempRGB;
  1069.  
  1070.     if (theItem == kCustomColor)  {
  1071.         tempRGB = gFGColor.rgb;
  1072.         if (GetColor(gZeroPt,"\pSelect a foreground color.",&tempRGB,&tempRGB))  {
  1073.             for(i=kSrcWindow; i <= kDstWindow; i++)
  1074.                 DrawWindow(i);
  1075.  
  1076.             gFGColor.menuIndex     = kCustomColor;
  1077.             gFGColor.rgb        = tempRGB;
  1078.  
  1079.             DrawBuffer(kBitWindow);
  1080.             DrawWindow(kBitWindow);
  1081.             }
  1082.         }
  1083.     else  {
  1084.         gFGColor.menuIndex     = theItem;
  1085.         gFGColor.rgb        = gRGBArray[theItem-1];
  1086.  
  1087.         DrawBuffer(kBitWindow);
  1088.         DrawWindow(kBitWindow);
  1089.         }
  1090. }
  1091.  
  1092.  
  1093. /*--------------------------------------------------------------------------------------*/
  1094. void  SelectBKColor    (short theItem)
  1095. {
  1096.     register    i;
  1097.     RGBColor    tempRGB;
  1098.     
  1099.     if (theItem == kCustomColor)  {
  1100.         tempRGB = gBKColor.rgb;
  1101.         if (GetColor(gZeroPt,"\pSelect a background color.",&tempRGB,&tempRGB))  {
  1102.             for(i=kSrcWindow; i <= kDstWindow; i++)
  1103.                 DrawWindow(i);
  1104.  
  1105.             gBKColor.menuIndex     = kCustomColor;
  1106.             gBKColor.rgb        = tempRGB;
  1107.  
  1108.             DrawBuffer(kBitWindow);
  1109.             DrawWindow(kBitWindow);
  1110.             }
  1111.         }
  1112.     else  {
  1113.         gBKColor.menuIndex     = theItem;
  1114.         gBKColor.rgb        = gRGBArray[theItem-1];
  1115.  
  1116.         DrawBuffer(kBitWindow);
  1117.         DrawWindow(kBitWindow);
  1118.         }
  1119. }
  1120.  
  1121.  
  1122. /*--------------------------------------------------------------------------------------*/
  1123. void  SelectOPColor (short theItem)
  1124. {
  1125.     register    i;
  1126.     RGBColor    tempRGB;
  1127.  
  1128.  
  1129.     if (theItem == kCustomColor)  {
  1130.         tempRGB = gOPColor.rgb;
  1131.         if (GetColor(gZeroPt,"\pSelect an OpColor.",&tempRGB,&tempRGB))  {
  1132.             for(i=kSrcWindow; i <= kDstWindow; i++)
  1133.                 DrawWindow(i);
  1134.  
  1135.             gOPColor.menuIndex     = kCustomColor;
  1136.             gOPColor.rgb        = tempRGB;
  1137.  
  1138.             DrawBuffer(kBitWindow);
  1139.             DrawWindow(kBitWindow);
  1140.             }
  1141.         }
  1142.     else  {
  1143.         gOPColor.menuIndex     = theItem;
  1144.         gOPColor.rgb        = gRGBArray[theItem-1];
  1145.  
  1146.         DrawBuffer(kBitWindow);
  1147.         DrawWindow(kBitWindow);
  1148.         }
  1149. }
  1150.  
  1151.  
  1152. /*--------------------------------------------------------------------------------------*/
  1153. void  SelectHiliteColor    (short theItem)
  1154. {
  1155.     register    i;
  1156.     RGBColor    tempRGB;
  1157.  
  1158.  
  1159.     if (theItem == kCustomColor)  {
  1160.         tempRGB = gHiliteColor.rgb;
  1161.         if (GetColor(gZeroPt,"\pSelect a hilite color.",&tempRGB,&tempRGB))  {
  1162.             for(i=kSrcWindow; i <= kDstWindow; i++)
  1163.                 DrawWindow(i);
  1164.  
  1165.             gHiliteColor.menuIndex     = kCustomColor;
  1166.             gHiliteColor.rgb        = tempRGB;
  1167.  
  1168.             DrawBuffer(kBitWindow);
  1169.             DrawWindow(kBitWindow);
  1170.             }
  1171.         }
  1172.     else  {
  1173.         gHiliteColor.menuIndex     = theItem;
  1174.         gHiliteColor.rgb        = gRGBArray[theItem-1];
  1175.  
  1176.         DrawBuffer(kBitWindow);
  1177.         DrawWindow(kBitWindow);
  1178.         }
  1179. }
  1180.  
  1181.  
  1182. /*--------------------------------------------------------------------------------------*/
  1183. void  SelectRgn(short rgnCode, short rgnType)
  1184. {
  1185.  
  1186.     gRList[rgnCode].type = rgnType;
  1187.     
  1188.     if (rgnType == kNoRgn)  {
  1189.         if (gRList[rgnCode].rgn != nil)  {
  1190.             DisposeRgn(gRList[rgnCode].rgn);
  1191.             gRList[rgnCode].rgn = nil;
  1192.             }
  1193.         }
  1194.     else  {
  1195.         gRList[rgnCode].rgn = NewRgn();
  1196.         OpenRgn();
  1197.  
  1198.         switch(rgnType)  {
  1199.             case kDiamondClip:    DrawDiamond();        break;
  1200.             case kOvalClip:        DrawOval();            break;
  1201.             case kStarClip:        DrawStar();            break;
  1202.             case kHoleClip:        DrawHole();            break;
  1203.             }
  1204.  
  1205.         CloseRgn(gRList[rgnCode].rgn);
  1206.         }
  1207.     
  1208.     DrawBuffer(kBitWindow);
  1209.     DrawWindow(kBitWindow);
  1210. }
  1211.  
  1212.  
  1213. /*--------------------------------------------------------------------------------------*/
  1214. Boolean  SelectTrap()
  1215. /*
  1216. //    This call allows the user to select which of the two copymas traps he wishes to test. 
  1217. */
  1218. {
  1219.     DialogPtr    theDlog;
  1220.     GrafPtr        holdPort;
  1221.     short        itemHit;
  1222.     
  1223.     Boolean        okHit            = false;
  1224.     Boolean        done            = false;
  1225.     Boolean        bufferChanged    = false;
  1226.     Boolean        contentChanged    = false;
  1227.  
  1228.     short        tempTrapSelect   = gTrapSelect;
  1229.     
  1230.     register     i;
  1231.     Str255        tempStr;
  1232.     
  1233.     
  1234.  
  1235.                 /*  Allocate and center the dialog  */
  1236.     CenterWRsrc(DLOG,TrapDlogID,vThird);
  1237.     theDlog = GetNewDialog(TrapDlogID, nil, (WindowPtr)-1);
  1238.     
  1239.                 /*  If the dialog has been allocated successfully - process the user's selections  */
  1240.     if (theDlog != nil)  {
  1241.     
  1242.                 /*  Save off the current port.  */
  1243.         GetPort(&holdPort);
  1244.         SetPort(theDlog);
  1245.         
  1246.                 /*  Set up user item divider lines */
  1247.         SetDlogItemProc(theDlog,diTrapLine1,(ProcPtr)FrameDlogItemRect);
  1248.         SetDlogItemProc(theDlog,diTrapLine2,(ProcPtr)FrameDlogItemRect);
  1249.         
  1250.                 /*  Init the radio buttons to reflect current selection.  */
  1251.         HandleRadioButtons(theDlog,diCopyMaskButton,diCopyBitsButton,tempTrapSelect+diCopyMaskButton);
  1252.     
  1253.                 /*  Display the dialog  */
  1254.         ShowWindow(theDlog);
  1255.         
  1256.                 /*  Process the user's actions  */
  1257.         do  {
  1258.             ModalDialog((ProcPtr)HandleOkayCancel, &itemHit);
  1259.             
  1260.             switch (itemHit)  {
  1261.                     case  ok:                okHit = true;        
  1262.                     case  cancel:            done  = true;
  1263.                                             break;
  1264.                 
  1265.                     case  diCopyMaskButton:
  1266.                     case  diCopyDeepButton:
  1267.                     case  diCopyBitsButton: HandleRadioButtons(theDlog,diCopyMaskButton,diCopyBitsButton,itemHit);
  1268.                                             tempTrapSelect  = itemHit - diCopyMaskButton;
  1269.                                             break;
  1270.                     }
  1271.             }  while ( !done );
  1272.             
  1273.         DisposDialog(theDlog);
  1274.         SetPort(holdPort);
  1275.         }
  1276.         
  1277.     if ((okHit) && (gTrapSelect != tempTrapSelect))  {
  1278.         for(i=kSrcWindow; i <= kBitWindow; i++)
  1279.             DrawWindow(i);
  1280.             
  1281.         gTrapSelect = tempTrapSelect;
  1282.         GetIndString(&tempStr, kTitleStrings, gTrapSelect+4);
  1283.         SetWTitle(gWList[kBitWindow].window,tempStr); 
  1284.         
  1285.         ShowHide(gWList[kMskWindow].window, !(gTrapSelect==kCopyBits));
  1286.     
  1287.         DrawBuffer(kBitWindow);
  1288.         DrawWindow(kBitWindow);
  1289.         }
  1290.         
  1291.     return(okHit);
  1292. }
  1293.  
  1294.  
  1295. /*--------------------------------------------------------------------------------------*/
  1296. void  NeedSystem7Dlog()
  1297. /*
  1298. //    This dialog alerts the user that system 7.0 is needed for the app to run. 
  1299. */
  1300. {
  1301.     DialogPtr    theDlog;
  1302.     GrafPtr        holdPort;
  1303.     short        itemHit;
  1304.     Boolean        done        = false;
  1305.     
  1306.     
  1307.                 /*  Allocate and center the dialog  */
  1308.     CenterWRsrc(DLOG,Sys7DlogID,vThird);
  1309.     theDlog = GetNewDialog(Sys7DlogID, nil, (WindowPtr)-1);
  1310.     
  1311.                 /*  If the dialog has been allocated successfully - process the user's selections  */
  1312.     if (theDlog != nil)  {
  1313.     
  1314.                 /*  Save off the current port.  */
  1315.         GetPort(&holdPort);
  1316.         SetPort(theDlog);
  1317.  
  1318.         FrameDlogButton    (theDlog,ok);
  1319.             
  1320.                 /*  Display the dialog  */
  1321.         ShowWindow(theDlog);
  1322.         
  1323.                 /*  Process the user's actions  */
  1324.         do  {
  1325.         
  1326.             ModalDialog((ProcPtr)HandleOkayCancel, &itemHit);
  1327.             done = (itemHit == ok);     
  1328.                 
  1329.             }  while ( !done );
  1330.             
  1331.         DisposDialog(theDlog);
  1332.         SetPort(holdPort);
  1333.         }
  1334. }
  1335.  
  1336.  
  1337. /*--------------------------------------------------------------------------------------*/
  1338. void  AboutBitBlitz()
  1339. { 
  1340.  
  1341.     DialogPtr    theDlog;
  1342.     GrafPtr        holdPort;
  1343.     short        itemHit;
  1344.     Boolean        done            = false;
  1345.  
  1346.  
  1347.  
  1348.     CenterWRsrc(DLOG,AboutBoxDlogID,vThird);
  1349.     theDlog = GetNewDialog(AboutBoxDlogID, nil, (WindowPtr)-1);
  1350.  
  1351.  
  1352.     if (theDlog != nil)  {
  1353.     
  1354.                 /*  Save off the current port.  */
  1355.         GetPort(&holdPort);
  1356.         SetPort(theDlog);
  1357.         
  1358.     
  1359.                 /*  Display the dialog  */
  1360.         ShowWindow(theDlog);
  1361.         
  1362.         
  1363.                 /*  Display about box until mouseDown  */
  1364.         do  {
  1365.             ModalDialog((ProcPtr)HandleOkayCancel, &itemHit);
  1366.             done  = (itemHit == 1);
  1367.             }  while ( !done );
  1368.             
  1369.             
  1370.             /*  Cleanup before returning  */
  1371.         DisposDialog(theDlog);
  1372.         SetPort(holdPort);
  1373.         }
  1374. }
  1375.  
  1376.  
  1377. /*======================================================================================*/
  1378. /*  Offscreen buffer imaging routines     */
  1379.  
  1380. /*--------------------------------------------------------------------------------------*/
  1381. void  FillSolid(RGBColor *theRGB, Rect *boundRect)
  1382. /*    
  1383. //    FillSolid() preserves and restores the current foreground color setting while filling
  1384. //    the specified Rect with the desired color.
  1385. */
  1386. {
  1387.     RGBColor    holdRGB;     
  1388.  
  1389.     GetForeColor(&holdRGB);
  1390.     
  1391.     RGBForeColor(theRGB);
  1392.     PaintRect(boundRect);
  1393.     
  1394.     RGBForeColor(&holdRGB);
  1395. }
  1396.  
  1397.  
  1398. /*--------------------------------------------------------------------------------------*/    
  1399. void  DoCopy()
  1400. /*    
  1401. //    DoCopy() updates the buffer associated with the copy window.  This update takes 
  1402. //    two steps.  Since the contents of the specified destination bitmap are overwritten by 
  1403. //  the copy result we keep both a destination window and the copy window.  Before performing 
  1404. //  the copy trap, the contents of the destination window's buffer are copied into the copy
  1405. //  window's buffer.  This buffer is then passed along with the source and mask window's buffers
  1406. //  to the copy routine.  
  1407. */
  1408. {
  1409.     GrafPtr            holdPort;
  1410.     GDHandle        holdDevice;
  1411.     BitMap            *srcBits, *mskBits, *dstBits;
  1412.     Rect            *srcRect, *mskRect, *dstRect;
  1413.     PixMapHandle    srcBuffer, mskBuffer, dstBuffer, bitBuffer;
  1414.  
  1415.  
  1416.             /*  If the user selects to use screen bits for the copy call the buffer pointer
  1417.             //  that is passed to the copy call is set to the window's portbits.
  1418.             */
  1419.     if (gUseScreenBits) {
  1420.         srcBits = &gWList[kSrcWindow].window->portBits;
  1421.         srcRect = &gWList[kSrcWindow].window->portRect;
  1422.  
  1423.         if (gWList[kMskWindow].bufferType == kBitMap) {
  1424.             mskBits = &gWList[kMskWindow].buffer.bitmap->portBits;
  1425.             mskRect = &gWList[kMskWindow].buffer.bitmap->portBits.bounds;
  1426.             }
  1427.         else  {
  1428.             mskBuffer  = GetGWorldPixMap(gWList[kMskWindow].buffer.gworld);
  1429.             LockPixels(mskBuffer);
  1430.             mskBits       = *mskBuffer;
  1431.             mskRect    = &gWList[kMskWindow].buffer.gworld->portRect;
  1432.             }
  1433.         
  1434.             /* The cursor is hidded during the copy so as not to interfere with the image  */
  1435.         HideCursor();
  1436.         }
  1437.         
  1438.             /* Otherwise, the offscreen gworld's portbits are passed  */
  1439.     else  {
  1440.         if (gWList[kSrcWindow].bufferType == kBitMap) {
  1441.             srcBits = &gWList[kSrcWindow].buffer.bitmap->portBits;
  1442.             srcRect = &gWList[kSrcWindow].buffer.bitmap->portBits.bounds;
  1443.             }
  1444.         else  {
  1445.             srcBuffer  = GetGWorldPixMap(gWList[kSrcWindow].buffer.gworld);
  1446.             LockPixels(srcBuffer);
  1447.             srcBits       = *srcBuffer;
  1448.             srcRect    = &gWList[kSrcWindow].buffer.gworld->portRect;
  1449.             }
  1450.  
  1451.         if (gWList[kMskWindow].bufferType == kBitMap) {
  1452.             mskBits = &gWList[kMskWindow].buffer.bitmap->portBits;
  1453.             mskRect = &gWList[kMskWindow].buffer.bitmap->portBits.bounds;
  1454.             }
  1455.         else  {
  1456.             mskBuffer  = GetGWorldPixMap(gWList[kMskWindow].buffer.gworld);
  1457.             LockPixels(mskBuffer);
  1458.             mskBits       = *mskBuffer;
  1459.             mskRect    = &gWList[kMskWindow].buffer.gworld->portRect;
  1460.             }
  1461.         }
  1462.  
  1463.     switch(gWList[kBitWindow].bufferType) {
  1464.         case kBitMap:    
  1465.             GetPort(&holdPort);
  1466.             SetPort(gWList[kBitWindow].buffer.bitmap);
  1467.             
  1468.             CopyBits(&gWList[kDstWindow].buffer.bitmap->portBits,            &gWList[kBitWindow].buffer.bitmap->portBits,
  1469.                      &gWList[kDstWindow].buffer.bitmap->portBits.bounds,       &gWList[kBitWindow].buffer.bitmap->portBits.bounds, srcCopy, NULL);
  1470.             
  1471.             if (gUseScreenBits) {
  1472.                 DrawWindow(kBitWindow);
  1473.                 dstBits = &gWList[kBitWindow].window->portBits;
  1474.                 dstRect = &gWList[kBitWindow].window->portRect;
  1475.                 }
  1476.             else  {
  1477.                 dstBits = &gWList[kBitWindow].buffer.bitmap->portBits;
  1478.                 dstRect = &gWList[kBitWindow].buffer.bitmap->portBits.bounds;
  1479.                 }
  1480.  
  1481.             SetEnv();
  1482.             if (gTrapSelect == kCopyMask)
  1483.                 CopyMask(srcBits, mskBits, dstBits, srcRect, mskRect, dstRect);
  1484.             else if (gTrapSelect == kCopyDeepMask) 
  1485.                 CopyMask2(srcBits, mskBits, dstBits, srcRect, mskRect, dstRect, gCopyMode, gRList[kMskRgn].rgn);
  1486.             else 
  1487.                 CopyBits (srcBits, dstBits, srcRect, dstRect, gCopyMode, gRList[kMskRgn].rgn);
  1488.             RestoreEnv();
  1489.                                               
  1490.             SetPort(holdPort);
  1491.             break;
  1492.             
  1493.         case kGWorld:
  1494.             dstBuffer = GetGWorldPixMap(gWList[kDstWindow].buffer.gworld);
  1495.             bitBuffer = GetGWorldPixMap(gWList[kBitWindow].buffer.gworld);
  1496.  
  1497.             LockPixels(dstBuffer);
  1498.             LockPixels(bitBuffer);
  1499.             
  1500.             GetGWorld(&(CGrafPtr)holdPort,&holdDevice);
  1501.             SetGWorld((CGrafPtr)gWList[kBitWindow].buffer.gworld,nil);
  1502.  
  1503.             CopyBits(*dstBuffer,                                   *bitBuffer,
  1504.                      &gWList[kDstWindow].buffer.gworld->portRect, &gWList[kBitWindow].buffer.gworld->portRect, srcCopy, nil);
  1505.  
  1506.             if (gUseScreenBits) {
  1507.                 SetGWorld((CGrafPtr)holdPort,holdDevice);
  1508.  
  1509.                 GetPort(&holdPort);
  1510.                 SetPort(gWList[kBitWindow].window);
  1511.  
  1512.                 DrawWindow(kBitWindow);
  1513.                 dstBits = &gWList[kBitWindow].window->portBits;
  1514.                 dstRect = &gWList[kBitWindow].window->portRect;
  1515.                 }
  1516.             else  {
  1517.                 dstBits = *bitBuffer;
  1518.                 dstRect = &gWList[kBitWindow].buffer.gworld->portRect;
  1519.                 }
  1520.  
  1521.             SetEnv();
  1522.             if (gTrapSelect == kCopyMask)
  1523.                 CopyMask(srcBits, mskBits, dstBits, srcRect, mskRect, dstRect);
  1524.             else if (gTrapSelect == kCopyDeepMask)
  1525.                 CopyMask2(srcBits, mskBits, dstBits, srcRect, mskRect, dstRect, gCopyMode, gRList[kMskRgn].rgn);
  1526.             else 
  1527.                 CopyBits (srcBits, dstBits, srcRect, dstRect,  gCopyMode, gRList[kMskRgn].rgn);
  1528.             RestoreEnv();
  1529.  
  1530.             if (gUseScreenBits) {
  1531.                 SetPort(holdPort);
  1532.                 
  1533.                 GetGWorld(&(CGrafPtr)holdPort,&holdDevice);
  1534.                 SetGWorld((CGrafPtr)gWList[kBitWindow].buffer.gworld,nil);
  1535.                 CopyBits(dstBits, *bitBuffer, dstRect, &gWList[kBitWindow].buffer.gworld->portRect, srcCopy, nil);
  1536.                 }
  1537.                          
  1538.             SetGWorld((CGrafPtr)holdPort,holdDevice);
  1539.             UnlockPixels(dstBuffer);
  1540.             UnlockPixels(bitBuffer);
  1541.             break;
  1542.         }
  1543.  
  1544.  
  1545.     if (gUseScreenBits) 
  1546.         ShowCursor();
  1547.     else {
  1548.         if (gWList[kSrcWindow].bufferType == kGWorld)
  1549.             UnlockPixels(srcBuffer);
  1550.  
  1551.         if (gWList[kMskWindow].bufferType == kGWorld)
  1552.             UnlockPixels(mskBuffer);
  1553.     
  1554.         }
  1555. }
  1556.  
  1557.  
  1558. /*--------------------------------------------------------------------------------------*/    
  1559. void  ImageBuffer(short windowCode)
  1560. /*
  1561. //    ImageBuffer() sets the current port in accordance with the buffer type, draws the image
  1562. //    designated by the contentType, and restores current port to its original setting.
  1563. */
  1564. {
  1565.     GrafPtr        holdPort;
  1566.     GDHandle    holdDevice;
  1567.     Rect        bufferRect;
  1568.  
  1569.  
  1570.     switch(gWList[windowCode].bufferType) {
  1571.         case kBitMap:    
  1572.             GetPort(&holdPort);
  1573.             SetPort(gWList[windowCode].buffer.bitmap);
  1574.             bufferRect = gWList[windowCode].buffer.bitmap->portBits.bounds;
  1575.             break;
  1576.             
  1577.         case kGWorld:
  1578.             LockPixels(GetGWorldPixMap(gWList[windowCode].buffer.gworld));
  1579.             GetGWorld(&holdPort,&holdDevice);
  1580.             SetGWorld(gWList[windowCode].buffer.gworld,nil);
  1581.             bufferRect = gWList[windowCode].buffer.gworld->portRect;
  1582.             break;
  1583.         }
  1584.             
  1585.     switch (gWList[windowCode].contentType)  {
  1586.         case kHLSRectBlend:      HLSRectBlend        (&bufferRect,gWList[windowCode].content.saturation); break;
  1587.         case kHLSHBlend:        HLSHLinearBlend        (&bufferRect,gWList[windowCode].content.saturation); break;
  1588.         case kHLSVBlend:        HLSVLinearBlend        (&bufferRect,gWList[windowCode].content.saturation); break;
  1589.         case kGrayRectBlend:    GrayRectBlend        (&bufferRect);                                         break;
  1590.         case kGrayHBlend:        GrayHLinearBlend    (&bufferRect);                                         break;
  1591.         case kGrayVBlend:        GrayVLinearBlend    (&bufferRect);                                         break;
  1592.         case kGrayPatRectBlend: GrayPatRectBlend    (&bufferRect);                                          break;
  1593.         case kGrayPatHBlend:    GrayPatHLinearBlend (&bufferRect);                                          break;
  1594.         case kGrayPatVBlend:    GrayPatVLinearBlend (&bufferRect);                                          break;
  1595.         case kSolidRGB:            FillSolid            (&gWList[windowCode].content.RGB,&bufferRect);         break;
  1596.         case kPICT:                if (gWList[windowCode].content.pictInfo != nil)
  1597.                                     DrawPicture(gWList[windowCode].content.pictInfo,&bufferRect);                        
  1598.                                     break;
  1599.         }
  1600.     
  1601.     switch(gWList[windowCode].bufferType) {
  1602.         case kBitMap:    SetPort  (holdPort);                
  1603.                         break;
  1604.         case kGWorld:    SetGWorld(holdPort,holdDevice);        
  1605.                         UnlockPixels(GetGWorldPixMap(gWList[windowCode].buffer.gworld));
  1606.                         break;
  1607.         }
  1608. }
  1609.  
  1610.  
  1611. /*--------------------------------------------------------------------------------------*/    
  1612. void  DrawBuffer(short windowCode)
  1613. /*    
  1614. //    DrawBuffer() redraws the specified window's offscreen buffer.
  1615. */
  1616. {    
  1617.     if (windowCode == kBitWindow) 
  1618.         DoCopy();
  1619.     else
  1620.         ImageBuffer(windowCode);
  1621. }
  1622.  
  1623.  
  1624.  
  1625. /*======================================================================================*/
  1626. /*  Offscreen-to-onscreen transferral     */
  1627.  
  1628. /*--------------------------------------------------------------------------------------*/
  1629. void  DrawWindow(short windowCode)
  1630. /*    
  1631. //    DrawWindow() draws the current contents of the specified window's buffer to that window.
  1632. */
  1633. {
  1634.     GrafPtr            holdPort;
  1635.     PixMapHandle    windowBuffer;
  1636.     
  1637.         
  1638.                 /*  Save the current port setting and set the current port to the specified window  */
  1639.     GetPort(&holdPort);
  1640.     SetPort(gWList[windowCode].window);
  1641.     
  1642.                 /*  Switch off the current buffer type setting to perform the appropriate copybits  */
  1643.     switch(gWList[windowCode].bufferType) {
  1644.         case kBitMap:    
  1645.             CopyBits(&gWList[windowCode].buffer.bitmap->portBits,            &gWList[windowCode].window->portBits,
  1646.                      &gWList[windowCode].buffer.bitmap->portBits.bounds,       &gWList[windowCode].window->portRect, srcCopy, NULL);
  1647.             break;
  1648.             
  1649.         case kGWorld:
  1650.             windowBuffer = GetGWorldPixMap(gWList[windowCode].buffer.gworld);
  1651.             LockPixels(windowBuffer);
  1652.             CopyBits(*windowBuffer,                               &gWList[windowCode].window->portBits,
  1653.                      &gWList[windowCode].buffer.gworld->portRect, &gWList[windowCode].window->portRect, srcCopy, NULL);
  1654.             UnlockPixels(windowBuffer);
  1655.             break;
  1656.         }
  1657.  
  1658.                 /*  Restore the current port to its original setting.  */
  1659.     SetPort(holdPort);
  1660. }
  1661.  
  1662.  
  1663.  
  1664. /*======================================================================================*/
  1665. /*  Window/Buffer resizing routines  */
  1666.  
  1667. /*--------------------------------------------------------------------------------------*/
  1668. Boolean  ResizeTestWindow(Point *newDimen, short windowCode)
  1669. /*    
  1670. //    ResizeWindow() sizes the specifed window to the new dimensions.
  1671. */
  1672. {
  1673.     Rect        tempRect, oldRect;
  1674.     Boolean        bufferScaled;
  1675.     GrafPtr        tempBits;
  1676.     GWorldFlags    gwError;
  1677.     
  1678.     
  1679.     switch(gWList[windowCode].bufferType) {
  1680.         case kBitMap:            
  1681.             oldRect  =  tempRect = gWList[windowCode].buffer.bitmap->portBits.bounds;
  1682.             tempRect.bottom       = tempRect.top  + newDimen->v;
  1683.             tempRect.right        = tempRect.left + newDimen->h;
  1684.     
  1685.             DisposeOSBitmap(gWList[windowCode].buffer.bitmap);
  1686.             
  1687.             bufferScaled     = CreateOSBitmap(&tempBits,&tempRect);
  1688.             if (bufferScaled)  
  1689.                 gWList[windowCode].buffer.bitmap = tempBits;
  1690.             else
  1691.                 CreateOSBitmap(&gWList[windowCode].buffer.bitmap,&oldRect);            
  1692.             break;
  1693.         
  1694.         case kGWorld:
  1695.             tempRect         = gWList[windowCode].buffer.gworld->portRect;
  1696.             tempRect.bottom  = tempRect.top  + newDimen->v;
  1697.             tempRect.right   = tempRect.left + newDimen->h;
  1698.             
  1699.             gwError          = UpdateGWorld(&gWList[windowCode].buffer.gworld, gWList[windowCode].bufferDepth, &tempRect, nil, nil, clipPix);
  1700.             bufferScaled     = ((gwError & gwFlagErr) == 0);
  1701.             break;
  1702.         }
  1703.  
  1704.     if (bufferScaled)  {
  1705.         if (windowCode != kBitWindow) 
  1706.             DrawBuffer(windowCode);
  1707.         }
  1708.     else
  1709.         OKRsrcAlert(kErrorStrings,kResizeMemErr);
  1710.         
  1711.     return(bufferScaled);
  1712. }
  1713.  
  1714.  
  1715.  
  1716. /*======================================================================================*/
  1717. /*  Test Window allocation/disposal routines  */
  1718.  
  1719.  
  1720. /*--------------------------------------------------------------------------------------*/    
  1721. void  CalcWindowRect(Rect *windowRect, short windowCode)
  1722. /*  
  1723. //  This procedure calculates the window rect for the window designated by windowCode.
  1724. //  It essentially divides the screen into 4 equal quadrants and insets the rect defining
  1725. //  the window's rect appropriately in order to have it positioned correctly on whatever
  1726. //  size screen the application is run.
  1727. */
  1728. {
  1729.     #define        kTitleBarHeight        20   
  1730.     #define        kWindowSep            10        /*  # pixels between windows and space between edge    */
  1731.                                             /*    of screen and window                              */
  1732.  
  1733.     Rect        screenRect;
  1734.     Point        windowCenter;
  1735.  
  1736.     screenRect = qd.screenBits.bounds;
  1737.     screenRect.top += MBarHeight;
  1738.  
  1739.     windowCenter.h    = screenRect.left  + (HRectLength(&screenRect) >> 1);
  1740.     windowCenter.v    = screenRect.top   + (VRectLength(&screenRect) >> 1);
  1741.     
  1742.     switch (windowCode)  {
  1743.         case kSrcWindow:
  1744.             SetRect(windowRect, screenRect.left+kWindowSep, 
  1745.                                 screenRect.top+kWindowSep+kTitleBarHeight, 
  1746.                                 windowCenter.h-(kWindowSep/2),  
  1747.                                 windowCenter.v-(kWindowSep/2));
  1748.             break;
  1749.             
  1750.         case kMskWindow:
  1751.             SetRect(windowRect, windowCenter.h+(kWindowSep/2),
  1752.                                 screenRect.top+kWindowSep+kTitleBarHeight,
  1753.                                 screenRect.right-kWindowSep,
  1754.                                 windowCenter.v-(kWindowSep/2));
  1755.             break;
  1756.             
  1757.         case kDstWindow:
  1758.             SetRect(windowRect, screenRect.left+kWindowSep,
  1759.                                 windowCenter.v+(kWindowSep/2)+kTitleBarHeight,
  1760.                                 windowCenter.h-(kWindowSep/2),
  1761.                                 screenRect.bottom-kWindowSep);
  1762.             break;
  1763.             
  1764.         case kBitWindow:
  1765.             SetRect(windowRect ,windowCenter.h+(kWindowSep/2),
  1766.                                 windowCenter.v+(kWindowSep/2)+kTitleBarHeight,
  1767.                                 screenRect.right-kWindowSep,
  1768.                                 screenRect.bottom-kWindowSep);
  1769.             break;
  1770.         }
  1771. }
  1772.  
  1773.  
  1774. /*--------------------------------------------------------------------------------------*/    
  1775. Boolean    CreateTestWindows()
  1776. {
  1777. /*  This function allocates, initializes, and displays the four test windows.  If an error 
  1778. //    occurs during this process and error message is displayed.  All memory allocated is 
  1779. //  disposed.  And false is returned so that the application will terminate from main. 
  1780. */  
  1781.     register    i;
  1782.     Rect        tempRect;
  1783.     Str255        title;
  1784.     
  1785.     
  1786.     for (i = kSrcWindow; i <= kBitWindow; i++)  {
  1787.         CalcWindowRect(&tempRect,i);
  1788.           GetIndString(&title, kTitleStrings, i+1);
  1789.  
  1790.         if (gColorAvail)
  1791.             gWList[i].window = NewCWindow(nil,&tempRect,title,true,documentProc,(WindowPtr)-1, false,0);
  1792.         else
  1793.             gWList[i].window = NewWindow(nil,&tempRect,title,true,documentProc,(WindowPtr)-1, false,0);
  1794.         if  (gWList[i].window == nil)
  1795.             goto handle_init_error;
  1796.             
  1797.         if  (!CreateWindowBuffer(i))
  1798.             goto handle_init_error;
  1799.         
  1800.         DrawBuffer(i);        
  1801.         DrawWindow(i);
  1802.         }
  1803.         
  1804.     return(true);
  1805.  
  1806.     handle_init_error:  DisposeTestWindows();
  1807.                         OKRsrcAlert(kErrorStrings,kBootMemErr);
  1808.                         return(false);
  1809. }
  1810.  
  1811.  
  1812. /*--------------------------------------------------------------------------------------*/
  1813. void    DisposeTestWindows()
  1814. /*
  1815. //    This procedure takes care of disposing all memory allocated in association with any 
  1816. //    of the app windows before the application quits either normally or in response to an
  1817. //  unrecoverable error.
  1818. */
  1819. {    
  1820.     register i;
  1821.     
  1822.     for (i = kSrcWindow; i <= kBitWindow; i++)  {
  1823.         if ((gWList[i].contentType == kPICT) && (gWList[i].content.pictInfo != nil))
  1824.             DisposHandle((Handle)gWList[i].content.pictInfo);
  1825.         DisposeWindowBuffer(i);    
  1826.         if (gWList[i].window != nil)
  1827.             DisposeWindow(gWList[i].window);
  1828.         }
  1829. }
  1830.